﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Data.Linq;
using System.Windows.Forms;
using System.Data.SqlClient;
using QLTVNEW.Report;
using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
using System.Collections;
using System.Drawing;
using System.Drawing.Printing;
namespace QLTVNEW
{
    public partial class frmMuonNhieuNhat : DevComponents.DotNetBar.Office2007Form
    {
        public frmMuonNhieuNhat()
        {
            InitializeComponent();
        }
        QLTVDataContext db = new QLTVDataContext();

       // PrintDocument MyPrintDocument;
        // The class that will do the printing process.
      //  DataGridViewPrinter MyDataGridViewPrinter;
       //private bool SetupThePrinting()
       // {
       //     PrintDialog MyPrintDialog = new PrintDialog();
       //     MyPrintDialog.AllowCurrentPage = false;
       //     MyPrintDialog.AllowPrintToFile = false;
       //     MyPrintDialog.AllowSelection = false;
       //     MyPrintDialog.AllowSomePages = false;
       //     MyPrintDialog.PrintToFile = false;
       //     MyPrintDialog.ShowHelp = false;
       //     MyPrintDialog.ShowNetwork = false;

       //     if (MyPrintDialog.ShowDialog() != DialogResult.OK)
       //         return false;

       //     MyPrintDocument.DocumentName = "Customers Report";
       //     MyPrintDocument.PrinterSettings =
       //                         MyPrintDialog.PrinterSettings;
       //     MyPrintDocument.DefaultPageSettings =
       //     MyPrintDialog.PrinterSettings.DefaultPageSettings;
       //     MyPrintDocument.DefaultPageSettings.Margins =
       //                      new Margins(40, 40, 40, 40);

       //     if (MessageBox.Show("Do you want the report to be centered on the page",
       //         "InvoiceManager - Center on Page", MessageBoxButtons.YesNo,
       //         MessageBoxIcon.Question) == DialogResult.Yes)
       //         MyDataGridViewPrinter = new DataGridViewPrinter(dataGridViewX1,
       //         MyPrintDocument, true, true, "Customers", new Font("Tahoma", 18,
       //         FontStyle.Bold, GraphicsUnit.Point), Color.Black, true);
       //     else
       //         MyDataGridViewPrinter = new DataGridViewPrinter(dataGridViewX1,
       //         MyPrintDocument, false, true, "Customers", new Font("Tahoma", 18,
       //         FontStyle.Bold, GraphicsUnit.Point), Color.Black, true);

       //     return true;
       // }
        private void frmMuonNhieuNhat_Load(object sender, EventArgs e)
        {
            dateTimeInput10.Value = DateTime.Now;
        }

  
        string thang = "";
        string nam = "";
        void GetTT()
        {
            string s = dateTimeInput10.Value.ToString("dd/MM/yyyy");
            s = s.Trim();
            string ngay = s.Substring(0, s.IndexOf('/'));
            thang = s.Substring(s.IndexOf('/') + 1, s.LastIndexOf('/') - ngay.Length - 1);
            nam = s.Substring(s.LastIndexOf('/') + 1);
        }
        private void buttonX1_Click_1(object sender, EventArgs e)
        {
            GetTT();
            dataGridViewX1.DataSource = (db.uspMuonNhieuNhat(thang, nam));
           
        }
     
        private void btncancel_Click(object sender, EventArgs e)
        {
            this.Close();
            //printPreviewDialog1.Document = printDocument1;
            //printPreviewDialog1.Show();
           
            // Print
            //if (SetupThePrinting())
            //    MyPrintDocument.Print();
        }
        private void MyPrintDocument_PrintPage(object sender,System.Drawing.Printing.PrintPageEventArgs e)
        {
            //bool more = MyDataGridViewPrinter.DrawDataGridView(e.Graphics);
            //if (more == true)
            //    e.HasMorePages = true;
        }
        private void printDocument1_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
        {
            //Bitmap bm = new Bitmap(this.dataGridViewX1.Width, this.dataGridViewX1.Height);
            //this.dataGridViewX1.DrawToBitmap(bm, new Rectangle(0, 0, this.dataGridViewX1.Width, this.dataGridViewX1.Height));
            //e.Graphics.DrawImage(bm, 0, 0);
            Bitmap bitmap = new Bitmap(dataGridViewX1.Width, dataGridViewX1.Height);

            this.dataGridViewX1.DrawToBitmap(bitmap, dataGridViewX1.ClientRectangle);

            e.Graphics.DrawImage(bitmap, new Point(50, 50));
        }



        private void buttonX1_Click(object sender, EventArgs e)
        {

        }

        private void buttonX2_Click_1(object sender, EventArgs e)
        {
           try
           {
               printDocument1.Print();
           }
           catch (System.Exception ex)
           {
               MessageBox.Show(ex.Message,"Thông Báo",MessageBoxButtons.OK,MessageBoxIcon.Warning);
           }

           
        }
    }
 
#region 
   class DataGridViewPrinter
    {
        // The DataGridView Control which will be printed
        private DataGridView TheDataGridView;
        // The PrintDocument to be used for printing
        private PrintDocument ThePrintDocument;
        // Determine if the report will be
        // printed in the Top-Center of the page
        private bool IsCenterOnPage;
        // Determine if the page contain title text
        private bool IsWithTitle;
        // The title text to be printed
        // in each page (if IsWithTitle is set to true)
        private string TheTitleText;
        // The font to be used with the title
        // text (if IsWithTitle is set to true)
        private Font TheTitleFont;
        // The color to be used with the title
        // text (if IsWithTitle is set to true)
        private Color TheTitleColor;
        // Determine if paging is used
        private bool IsWithPaging;

        // A static parameter that keep track
        // on which Row (in the DataGridView control)
        // that should be printed
        static int CurrentRow;

        static int PageNumber;

        private int PageWidth;
        private int PageHeight;
        private int LeftMargin;
        private int TopMargin;
        private int RightMargin;
        private int BottomMargin;

        // A parameter that keep track
        // on the y coordinate of the page,
        // so the next object to be printed
        // will start from this y coordinate
        private float CurrentY;

        private float RowHeaderHeight;
        private List<float> RowsHeight;
        private List<float> ColumnsWidth;
        private float TheDataGridViewWidth;

        // Maintain a generic list to hold start/stop
        // points for the column printing
        // This will be used for wrapping
        // in situations where the DataGridView will not
        // fit on a single page
        private List<int[]> mColumnPoints;
        private List<float> mColumnPointsWidth;
        private int mColumnPoint;

        // The class constructor
        public DataGridViewPrinter(DataGridView aDataGridView,
            PrintDocument aPrintDocument,
            bool CenterOnPage, bool WithTitle,
            string aTitleText, Font aTitleFont,
            Color aTitleColor, bool WithPaging)
        {
            TheDataGridView = aDataGridView;
            ThePrintDocument = aPrintDocument;
            IsCenterOnPage = CenterOnPage;
            IsWithTitle = WithTitle;
            TheTitleText = aTitleText;
            TheTitleFont = aTitleFont;
            TheTitleColor = aTitleColor;
            IsWithPaging = WithPaging;

            PageNumber = 0;

            RowsHeight = new List<float>();
            ColumnsWidth = new List<float>();

            mColumnPoints = new List<int[]>();
            mColumnPointsWidth = new List<float>();

            // Claculating the PageWidth and the PageHeight
            if (!ThePrintDocument.DefaultPageSettings.Landscape)
            {
                PageWidth =
                  ThePrintDocument.DefaultPageSettings.PaperSize.Width;
                PageHeight =
                  ThePrintDocument.DefaultPageSettings.PaperSize.Height;
            }
            else
            {
                PageHeight =
                  ThePrintDocument.DefaultPageSettings.PaperSize.Width;
                PageWidth =
                  ThePrintDocument.DefaultPageSettings.PaperSize.Height;
            }

            // Claculating the page margins
            LeftMargin = ThePrintDocument.DefaultPageSettings.Margins.Left;
            TopMargin = ThePrintDocument.DefaultPageSettings.Margins.Top;
            RightMargin = ThePrintDocument.DefaultPageSettings.Margins.Right;
            BottomMargin = ThePrintDocument.DefaultPageSettings.Margins.Bottom;

            // First, the current row to be printed
            // is the first row in the DataGridView control
            CurrentRow = 0;
        }

        // The function that calculate
        // the height of each row (including the header row),
        // the width of each column (according
        // to the longest text in all its cells including
        // the header cell), and the whole DataGridView width
        private void Calculate(Graphics g)
        {
            if (PageNumber == 0)
            // Just calculate once
            {
                SizeF tmpSize = new SizeF();
                Font tmpFont;
                float tmpWidth;

                TheDataGridViewWidth = 0;
                for (int i = 0; i < TheDataGridView.Columns.Count; i++)
                {
                    tmpFont = TheDataGridView.ColumnHeadersDefaultCellStyle.Font;
                    if (tmpFont == null)
                        // If there is no special HeaderFont style,
                        // then use the default DataGridView font style
                        tmpFont = TheDataGridView.DefaultCellStyle.Font;

                    tmpSize = g.MeasureString(
                              TheDataGridView.Columns[i].HeaderText,
                              tmpFont);
                    tmpWidth = tmpSize.Width;
                    RowHeaderHeight = tmpSize.Height;

                    for (int j = 0; j < TheDataGridView.Rows.Count; j++)
                    {
                        tmpFont = TheDataGridView.Rows[j].DefaultCellStyle.Font;
                        if (tmpFont == null)
                            // If the there is no special font style of the
                            // CurrentRow, then use the default one associated
                            // with the DataGridView control
                            tmpFont = TheDataGridView.DefaultCellStyle.Font;

                        tmpSize = g.MeasureString("Anything", tmpFont);
                        RowsHeight.Add(tmpSize.Height);

                        tmpSize =
                            g.MeasureString(
                            TheDataGridView.Rows[j].Cells[i].
                                     EditedFormattedValue.ToString(),
                            tmpFont);
                        if (tmpSize.Width > tmpWidth)
                            tmpWidth = tmpSize.Width;
                    }
                    if (TheDataGridView.Columns[i].Visible)
                        TheDataGridViewWidth += tmpWidth;
                    ColumnsWidth.Add(tmpWidth);
                }

                // Define the start/stop column points
                // based on the page width and
                // the DataGridView Width
                // We will use this to determine
                // the columns which are drawn on each page
                // and how wrapping will be handled
                // By default, the wrapping will occurr
                // such that the maximum number of
                // columns for a page will be determine
                int k;

                int mStartPoint = 0;
                for (k = 0; k < TheDataGridView.Columns.Count; k++)
                    if (TheDataGridView.Columns[k].Visible)
                    {
                        mStartPoint = k;
                        break;
                    }

                int mEndPoint = TheDataGridView.Columns.Count;
                for (k = TheDataGridView.Columns.Count - 1; k >= 0; k--)
                    if (TheDataGridView.Columns[k].Visible)
                    {
                        mEndPoint = k + 1;
                        break;
                    }

                float mTempWidth = TheDataGridViewWidth;
                float mTempPrintArea = (float)PageWidth - (float)LeftMargin -
                    (float)RightMargin;

                // We only care about handling
                // where the total datagridview width is bigger
                // then the print area
                if (TheDataGridViewWidth > mTempPrintArea)
                {
                    mTempWidth = 0.0F;
                    for (k = 0; k < TheDataGridView.Columns.Count; k++)
                    {
                        if (TheDataGridView.Columns[k].Visible)
                        {
                            mTempWidth += ColumnsWidth[k];
                            // If the width is bigger
                            // than the page area, then define a new
                            // column print range
                            if (mTempWidth > mTempPrintArea)
                            {
                                mTempWidth -= ColumnsWidth[k];
                                mColumnPoints.Add(new int[] { mStartPoint, mEndPoint });
                                mColumnPointsWidth.Add(mTempWidth);
                                mStartPoint = k;
                                mTempWidth = ColumnsWidth[k];
                            }
                        }
                        // Our end point is actually
                        // one index above the current index
                        mEndPoint = k + 1;
                    }
                }
                // Add the last set of columns
                mColumnPoints.Add(new int[] { mStartPoint, mEndPoint });
                mColumnPointsWidth.Add(mTempWidth);
                mColumnPoint = 0;
            }
        }

        // The funtion that print the title, page number, and the header row
        private void DrawHeader(Graphics g)
        {
            CurrentY = (float)TopMargin;

            // Printing the page number (if isWithPaging is set to true)
            if (IsWithPaging)
            {
                PageNumber++;
                string PageString = "Page " + PageNumber.ToString();

                StringFormat PageStringFormat = new StringFormat();
                PageStringFormat.Trimming = StringTrimming.Word;
                PageStringFormat.FormatFlags = StringFormatFlags.NoWrap |
                    StringFormatFlags.LineLimit | StringFormatFlags.NoClip;
                PageStringFormat.Alignment = StringAlignment.Far;

                Font PageStringFont = new Font("Tahoma", 8, FontStyle.Regular,
                    GraphicsUnit.Point);

                RectangleF PageStringRectangle =
                   new RectangleF((float)LeftMargin, CurrentY,
                   (float)PageWidth - (float)RightMargin - (float)LeftMargin,
                   g.MeasureString(PageString, PageStringFont).Height);

                g.DrawString(PageString, PageStringFont,
                   new SolidBrush(Color.Black),
                   PageStringRectangle, PageStringFormat);

                CurrentY += g.MeasureString(PageString,
                                     PageStringFont).Height;
            }

            // Printing the title (if IsWithTitle is set to true)
            if (IsWithTitle)
            {
                StringFormat TitleFormat = new StringFormat();
                TitleFormat.Trimming = StringTrimming.Word;
                TitleFormat.FormatFlags = StringFormatFlags.NoWrap |
                    StringFormatFlags.LineLimit | StringFormatFlags.NoClip;
                if (IsCenterOnPage)
                    TitleFormat.Alignment = StringAlignment.Center;
                else
                    TitleFormat.Alignment = StringAlignment.Near;

                RectangleF TitleRectangle =
                    new RectangleF((float)LeftMargin, CurrentY,
                    (float)PageWidth - (float)RightMargin - (float)LeftMargin,
                    g.MeasureString(TheTitleText, TheTitleFont).Height);

                g.DrawString(TheTitleText, TheTitleFont,
                    new SolidBrush(TheTitleColor),
                    TitleRectangle, TitleFormat);

                CurrentY += g.MeasureString(TheTitleText, TheTitleFont).Height;
            }

            // Calculating the starting x coordinate
            // that the printing process will start from
            float CurrentX = (float)LeftMargin;
            if (IsCenterOnPage)
                CurrentX += (((float)PageWidth - (float)RightMargin -
                  (float)LeftMargin) - mColumnPointsWidth[mColumnPoint]) / 2.0F;

            // Setting the HeaderFore style
            Color HeaderForeColor =
                  TheDataGridView.ColumnHeadersDefaultCellStyle.ForeColor;
            if (HeaderForeColor.IsEmpty)
                // If there is no special HeaderFore style,
                // then use the default DataGridView style
                HeaderForeColor = TheDataGridView.DefaultCellStyle.ForeColor;
            SolidBrush HeaderForeBrush = new SolidBrush(HeaderForeColor);

            // Setting the HeaderBack style
            Color HeaderBackColor =
                  TheDataGridView.ColumnHeadersDefaultCellStyle.BackColor;
            if (HeaderBackColor.IsEmpty)
                // If there is no special HeaderBack style,
                // then use the default DataGridView style
                HeaderBackColor = TheDataGridView.DefaultCellStyle.BackColor;
            SolidBrush HeaderBackBrush = new SolidBrush(HeaderBackColor);

            // Setting the LinePen that will
            // be used to draw lines and rectangles
            // (derived from the GridColor property
            // of the DataGridView control)
            Pen TheLinePen = new Pen(TheDataGridView.GridColor, 1);

            // Setting the HeaderFont style
            Font HeaderFont = TheDataGridView.ColumnHeadersDefaultCellStyle.Font;
            if (HeaderFont == null)
                // If there is no special HeaderFont style,
                // then use the default DataGridView font style
                HeaderFont = TheDataGridView.DefaultCellStyle.Font;

            // Calculating and drawing the HeaderBounds        
            RectangleF HeaderBounds = new RectangleF(CurrentX, CurrentY,
                mColumnPointsWidth[mColumnPoint], RowHeaderHeight);
            g.FillRectangle(HeaderBackBrush, HeaderBounds);

            // Setting the format that will be
            // used to print each cell of the header row
            StringFormat CellFormat = new StringFormat();
            CellFormat.Trimming = StringTrimming.Word;
            CellFormat.FormatFlags = StringFormatFlags.NoWrap |
               StringFormatFlags.LineLimit | StringFormatFlags.NoClip;

            // Printing each visible cell of the header row
            RectangleF CellBounds;
            float ColumnWidth;
            for (int i = (int)mColumnPoints[mColumnPoint].GetValue(0);
                i < (int)mColumnPoints[mColumnPoint].GetValue(1); i++)
            {
                // If the column is not visible then ignore this iteration
                if (!TheDataGridView.Columns[i].Visible) continue;

                ColumnWidth = ColumnsWidth[i];

                // Check the CurrentCell alignment
                // and apply it to the CellFormat
                if (TheDataGridView.ColumnHeadersDefaultCellStyle.
                           Alignment.ToString().Contains("Right"))
                    CellFormat.Alignment = StringAlignment.Far;
                else if (TheDataGridView.ColumnHeadersDefaultCellStyle.
                         Alignment.ToString().Contains("Center"))
                    CellFormat.Alignment = StringAlignment.Center;
                else
                    CellFormat.Alignment = StringAlignment.Near;

                CellBounds = new RectangleF(CurrentX, CurrentY,
                             ColumnWidth, RowHeaderHeight);

                // Printing the cell text
                g.DrawString(TheDataGridView.Columns[i].HeaderText,
                             HeaderFont, HeaderForeBrush,
                   CellBounds, CellFormat);

                // Drawing the cell bounds
                // Draw the cell border only if the HeaderBorderStyle is not None
                if (TheDataGridView.RowHeadersBorderStyle !=
                                DataGridViewHeaderBorderStyle.None)
                    g.DrawRectangle(TheLinePen, CurrentX, CurrentY, ColumnWidth,
                        RowHeaderHeight);

                CurrentX += ColumnWidth;
            }

            CurrentY += RowHeaderHeight;
        }

        // The function that print a bunch of rows that fit in one page
        // When it returns true, meaning that
        // there are more rows still not printed,
        // so another PagePrint action is required
        // When it returns false, meaning that all rows are printed
        // (the CureentRow parameter reaches
        // the last row of the DataGridView control)
        // and no further PagePrint action is required
        private bool DrawRows(Graphics g)
        {
            // Setting the LinePen that will be used to draw lines and rectangles
            // (derived from the GridColor property of the DataGridView control)
            Pen TheLinePen = new Pen(TheDataGridView.GridColor, 1);

            // The style paramters that will be used to print each cell
            Font RowFont;
            Color RowForeColor;
            Color RowBackColor;
            SolidBrush RowForeBrush;
            SolidBrush RowBackBrush;
            SolidBrush RowAlternatingBackBrush;

            // Setting the format that will be used to print each cell
            StringFormat CellFormat = new StringFormat();
            CellFormat.Trimming = StringTrimming.Word;
            CellFormat.FormatFlags = StringFormatFlags.NoWrap |
                                     StringFormatFlags.LineLimit;

            // Printing each visible cell
            RectangleF RowBounds;
            float CurrentX;
            float ColumnWidth;
            while (CurrentRow < TheDataGridView.Rows.Count)
            {
                // Print the cells of the CurrentRow only if that row is visible
                if (TheDataGridView.Rows[CurrentRow].Visible)
                {
                    // Setting the row font style
                    RowFont = TheDataGridView.Rows[CurrentRow].DefaultCellStyle.Font;
                    // If the there is no special font style of the CurrentRow,
                    // then use the default one associated with the DataGridView control
                    if (RowFont == null)
                        RowFont = TheDataGridView.DefaultCellStyle.Font;

                    // Setting the RowFore style
                    RowForeColor =
                      TheDataGridView.Rows[CurrentRow].DefaultCellStyle.ForeColor;
                    // If the there is no special RowFore style of the CurrentRow,
                    // then use the default one associated with the DataGridView control
                    if (RowForeColor.IsEmpty)
                        RowForeColor = TheDataGridView.DefaultCellStyle.ForeColor;
                    RowForeBrush = new SolidBrush(RowForeColor);

                    // Setting the RowBack (for even rows) and the RowAlternatingBack
                    // (for odd rows) styles
                    RowBackColor =
                      TheDataGridView.Rows[CurrentRow].DefaultCellStyle.BackColor;
                    // If the there is no special RowBack style of the CurrentRow,
                    // then use the default one associated with the DataGridView control
                    if (RowBackColor.IsEmpty)
                    {
                        RowBackBrush = new SolidBrush(
                              TheDataGridView.DefaultCellStyle.BackColor);
                        RowAlternatingBackBrush = new
                            SolidBrush(
                            TheDataGridView.AlternatingRowsDefaultCellStyle.BackColor);
                    }
                    // If the there is a special RowBack style of the CurrentRow,
                    // then use it for both the RowBack and the RowAlternatingBack styles
                    else
                    {
                        RowBackBrush = new SolidBrush(RowBackColor);
                        RowAlternatingBackBrush = new SolidBrush(RowBackColor);
                    }

                    // Calculating the starting x coordinate
                    // that the printing process will
                    // start from
                    CurrentX = (float)LeftMargin;
                    if (IsCenterOnPage)
                        CurrentX += (((float)PageWidth - (float)RightMargin -
                            (float)LeftMargin) -
                            mColumnPointsWidth[mColumnPoint]) / 2.0F;

                    // Calculating the entire CurrentRow bounds                
                    RowBounds = new RectangleF(CurrentX, CurrentY,
                        mColumnPointsWidth[mColumnPoint], RowsHeight[CurrentRow]);

                    // Filling the back of the CurrentRow
                    if (CurrentRow % 2 == 0)
                        g.FillRectangle(RowBackBrush, RowBounds);
                    else
                        g.FillRectangle(RowAlternatingBackBrush, RowBounds);

                    // Printing each visible cell of the CurrentRow                
                    for (int CurrentCell = (int)mColumnPoints[mColumnPoint].GetValue(0);
                        CurrentCell < (int)mColumnPoints[mColumnPoint].GetValue(1);
                        CurrentCell++)
                    {
                        // If the cell is belong to invisible
                        // column, then ignore this iteration
                        if (!TheDataGridView.Columns[CurrentCell].Visible) continue;

                        // Check the CurrentCell alignment
                        // and apply it to the CellFormat
                        if (TheDataGridView.Columns[CurrentCell].DefaultCellStyle.
                                Alignment.ToString().Contains("Right"))
                            CellFormat.Alignment = StringAlignment.Far;
                        else if (TheDataGridView.Columns[CurrentCell].DefaultCellStyle.
                                Alignment.ToString().Contains("Center"))
                            CellFormat.Alignment = StringAlignment.Center;
                        else
                            CellFormat.Alignment = StringAlignment.Near;

                        ColumnWidth = ColumnsWidth[CurrentCell];
                        RectangleF CellBounds = new RectangleF(CurrentX, CurrentY,
                            ColumnWidth, RowsHeight[CurrentRow]);

                        // Printing the cell text
                        g.DrawString(
                          TheDataGridView.Rows[CurrentRow].Cells[CurrentCell].
                          EditedFormattedValue.ToString(), RowFont, RowForeBrush,
                          CellBounds, CellFormat);

                        // Drawing the cell bounds
                        // Draw the cell border only
                        // if the CellBorderStyle is not None
                        if (TheDataGridView.CellBorderStyle !=
                                    DataGridViewCellBorderStyle.None)
                            g.DrawRectangle(TheLinePen, CurrentX, CurrentY,
                                  ColumnWidth, RowsHeight[CurrentRow]);

                        CurrentX += ColumnWidth;
                    }
                    CurrentY += RowsHeight[CurrentRow];

                    // Checking if the CurrentY is exceeds the page boundries
                    // If so then exit the function and returning true meaning another
                    // PagePrint action is required
                    if ((int)CurrentY > (PageHeight - TopMargin - BottomMargin))
                    {
                        CurrentRow++;
                        return true;
                    }
                }
                CurrentRow++;
            }

            CurrentRow = 0;
            // Continue to print the next group of columns
            mColumnPoint++;

            if (mColumnPoint == mColumnPoints.Count)
            // Which means all columns are printed
            {
                mColumnPoint = 0;
                return false;
            }
            else
                return true;
        }

        // The method that calls all other functions
        public bool DrawDataGridView(Graphics g)
        {
            try
            {
                Calculate(g);
                DrawHeader(g);
                bool bContinue = DrawRows(g);
                return bContinue;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Operation failed: " + ex.Message.ToString(),
                    Application.ProductName + " - Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return false;
            }
        }
    }
#endregion

}
